

document.write("<p>//方法的几种类型</p>");
function People(name){
    this.name = name;
    // 对象方法或叫实例方法
    this.Introduce = function(){
        document.write("<p>My name is "+this.name+"</p>");
    }
    //People.Run = function(){
    //    document.write("<p>I can run"+"</p>");
    //}
}
// 类方法，类似于static方法，也可以放到People函数里面
People.Run = function(){
    document.write("<p>I can run"+"</p>");
}
// 原型方法
People.prototype.IntroduceChinese = function(){
    document.write("<p>我的名字叫"+this.name+"</p>");
}
var p1 = new People("Windking");
p1.Introduce();
//People.Introduce();   // Error!!

//p1.Run();             // Error!!
People.Run();

p1.IntroduceChinese();
//People.IntroduceChinese();  // Error!!



function baseClass(){
    this.showMsg = function(){
        document.write("<p>baseClass::showMsg");
        // 调用函数的this和函数内部的this还指的不是同一个对象
        document.write("<p>"+this.baseName1+"</p>")
    }
    // 没有this.是局部变量/私有变量，不能通过对象来访问
    baseName = "baseClass::name";
    // 实例变量
    this.baseName1 = "this.baseName1";
}
function extendClass(){
    this.showMsg = function(){
        document.write("<p>extendClass::showMsg");
        document.write("<p>"+this.baseName1+"</p>")
    }
    this.baseName1 = "this.extendName1";
}
extendClass.prototype = new baseClass();
var instExtend = new extendClass();
var instBase = new baseClass();
// 移到创建对象后面就没用了，原理方法在实例中无
//extendClass.prototype = new baseClass(); 
// 先去函数本体中找，有则调用，无则去prototype中找showMsg方法
instExtend.showMsg();   
// alert(inst.baseName)    // 不是属于对象的，没有this.


instBase.showMsg.call(instExtend);  // baseClass::showMsg; extendName1
instExtend.showMsg.call(instBase);  // ExtendClass::showMsg; baseName1

document.write(typeof(extendClass))
document.write(typeof(instExtend))


document.write("<p>//-------------------prototype-----------------------")
function Person(){
}
/* 一个函数编译成为以下结构
Person: function Person(){
    arguments: null
    caller: null
    length: 0
    name: "Person"
    prototype: Person
        constructor: function Person(){...}
        __proto__: Object // 比作父类指针
    __proto__: function Empty(){}
*/
function Person(name){
    this.name = name;
    Person.prototype.printName = function(){
        document.write("<p>"+this.name+"</p>");
    }
}
var personal1 = new Person("Byron");
var personal2 = new Person("David");
personal1.printName();  // Byron
personal2.printName();  // David
// 添加实例方法，添加后personal1.printName调用的是此方法，覆盖了原方法
personal1.printName = function(){   
    alert("personal1::printName");
}
/* 创建一个对象编译成为以下结构
personal1: Person
    name: "Byron"
    __proto__: Person
        constructor: function Person(name){...}
        printName: function(){}
        __proto__: Object

*/

personal1.printName();
// 实例化后，再向prototype中添加方法就挂了
//personal1.prototype.proName = function(){
//  alert("proName");
// }
//personal1.proName();

document.write("<p>//-----------------------end---------------------</p>")

